#include "TableauDynamique.h"



// Fonctions d'initialisation et de liberation
/**
@brief Initialise le tableau avec une taille de 100
**/
void initTabDyn(TableauDynamique *t)
{
    t -> tabEq = malloc(100*sizeof(Equipement));
    t -> capacite = 100;
    t -> tailleUtilisee = 0;
}

void libereTabDyn(TableauDynamique *t)
{
    assert(t!=NULL);
    if (t-> tabEq !=NULL)
        {
            free(t -> tabEq);
        }
    t -> capacite = 0;
    t -> tailleUtilisee = 0;
    t -> tabEq = NULL;
}

//Accesseurs
unsigned int getTailleTabDyn(const TableauDynamique *t)
/* Precondition : t prealablement initialise */
/* Resultat : nombre d'Equipements stockes dans t */
{
    assert (t!=NULL);
    return t->tailleUtilisee;
}

const Equipement *getPointeurTableauDynamique (const TableauDynamique *t)
{
    assert (t!=NULL);
    return t->tabEq;
}

Equipement* getIemeElementTabDyn(TableauDynamique *t, unsigned int i)
{
    assert(t!=NULL);
    assert(i>=0);
    assert(i<t->tailleUtilisee);
    return &(t->tabEq[i]);
}

//Mutateurs
Equipement* setIemeElementTabDyn(TableauDynamique *t, Equipement *eq, unsigned int i)
{
    assert(t!=NULL);
    assert(eq!=NULL);
    assert(i>=0);
    assert(i<t->tailleUtilisee);
    copierEquipement(&(t->tabEq[i]),eq);
}


// Fonctions de manipulation
void ajouterElementTabDyn(TableauDynamique *t, Equipement *eq)
{
    if (t->tabEq==NULL)
    {
        t->tabEq=malloc(100*sizeof(Equipement));
        copierEquipement(&(t->tabEq[0]),eq);
        t->capacite=100;
        t->tailleUtilisee=1;
    }
    else
    {
        if (t-> tailleUtilisee == t-> capacite)
        {
            int i;
            Equipement *temp = t->tabEq;
            t->tabEq = malloc(2*(t->capacite)*sizeof(Equipement));

            for(i=0;i< t->capacite; i++)
            {
                copierEquipement(&(t->tabEq[i]),&(temp[i]));
            }

            t->capacite = 2*(t->capacite);
            free(temp);
        }

    copierEquipement(&(t->tabEq[t->tailleUtilisee]),eq);
    t->tailleUtilisee=t->tailleUtilisee+1;
    }
}




void supprimerElementTabDyn( TableauDynamique *t, int position )
{
    int i;

    if(position<t->tailleUtilisee - 1)
        {for (i= position; i< t->tailleUtilisee - 1; i++)
            {
               copierEquipement(&(t->tabEq[i]),&(t->tabEq[i+1]));
            }
        }
    t->tailleUtilisee--;
}

//Test de non régression
void testRegressionTabDyn()
{
    printf("###  Test du module tableau dynamique ### \n");

    TableauDynamique tab;
    Equipement eq1;
    Equipement eq2;
    Equipement *eq;


    //Test de la fonction d'initialisation
    initTabDyn(&tab);

    printf("-- Fonction d'initialisation testees avec succes -- \n");

    //Test des fonctions de manipulation
    parametreEquipement (&eq1,1,1,1,1,1,1,1);
    parametreEquipement (&eq2,2,2,2,2,2,2,2);

    ajouterElementTabDyn(&tab, &eq1);
    ajouterElementTabDyn(&tab, &eq2);

    assert (getTailleTabDyn(&tab)==2);

    supprimerElementTabDyn(&tab,1);

    printf("-- Fonctions de manipulation testees avec succes  -- \n");


    //Test de accesseurs et mutateurs
    assert (getTailleTabDyn(&tab)==1);

    eq =getIemeElementTabDyn(&tab,0);
    assert (getidEquipement(eq) == 1);
    assert (getdimXEquipement(eq) == 1);
    assert (getdimYEquipement(eq) == 1);
    assert (getposXEquipement(eq) == 1);
    assert (getposYEquipement(eq) == 1);
    assert (getdegatsEquipement(eq) == 1);
    assert (getprotectionEquipement(eq) == 1);

    printf("-- Accesseurs et mutateurs testes avec succes  -- \n");

    //Test de la fonction de liberation

    libereTabDyn(&tab);

    printf("-- Fonction de liberation testee avec succes  -- \n");

    printf("***  Test du module tableau dynamique realise avec succes *** \n\n\n");

}
